import { SkillBase } from '@/assets/scripts/skill/SkillBase.js'
import { GameObject } from '@/assets/scripts/GameObject.js'

// 治疗术技能
export class Heal extends SkillBase {
    constructor(player) {
        super(player, 10) // 10秒冷却时间
        this.player = player
        this.skillKey = 'e'
        this.skillName = 'heal'
        this.healAmount = 30 // 治疗量

        // 加载技能图标
        this.load_icon('https://www.helloimg.com/i/2025/04/11/67f8dfdf1e81b.jpg')
    }

    // 添加resize方法，更新治疗参数以匹配窗口大小变化
    resize() {
        // 治疗量可以根据窗口大小变化而调整（如果需要）
    }

    // 施放技能 - 联机模式下只验证冷却，实际治疗由服务器处理
    cast() {
        // 检查player是否有效
        if (!this.player) {
            console.error("治疗技能施放失败: player对象为null");
            return false;
        }
        
        // 如果玩家已死亡，返回失败
        if (this.player.is_dead) {
            return false
        }
        
        // 调用父类的cast方法检查冷却，如果在冷却中则返回失败
        if (!super.cast()) {
            return false
        }

        // 在单人游戏模式下，直接在本地应用治疗效果
        if (this.player.gameMap && this.player.gameMap.constructor.name === 'SingleMap') {
            // 回复血量（不超过最大值）
            this.player.info.hp = Math.min(this.player.maxHp, this.player.info.hp + this.healAmount)
            
            // 创建治疗特效
            this.create_heal_effect()
        }

        return true
    }

    // 创建治疗特效 - 分离出来方便联机时使用
    create_heal_effect() {
        try {
            // 检查player对象是否存在
            if (!this.player) {
                console.error("创建治疗效果失败: player对象不存在");
                return;
            }
            
            // 确保gameMap已设置
            const gameMap = this.player.gameMap || this.gameMap;
            if (!gameMap) {
                console.error("创建治疗效果失败: gameMap对象不存在");
                return;
            }
            
            // 创建并添加治疗效果实体
            new HealEffectEntity(gameMap, {
                x: this.player.info.x,
                y: this.player.info.y,
                radius: this.player.info.radius * 1.5,
                player: this.player,
            });
        } catch (error) {
            console.error("创建治疗效果时出错:", error);
        }
    }
}

// 治疗效果实体类
class HealEffectEntity extends GameObject {
    constructor(gameMap, info) {
        super();
        try {
            // 验证必要参数
            if (!gameMap || !info) {
                console.error("创建治疗效果失败: 缺少必要参数");
                this.destroy();
                return;
            }
            
            this.gameMap = gameMap;
            this.info = info;
            this.lifespan = 800; // 效果持续时间(毫秒)
            this.particles = [];
            this.sparkles = [];
            this.lastParticleTime = Date.now();
            this.particleInterval = 30; // 生成粒子的时间间隔（毫秒）

            // 创建初始粒子
            this.createParticles();
        } catch (error) {
            console.error("初始化治疗效果对象时出错:", error);
            this.destroy();
        }
    }
    
    // 销毁时清理
    on_destroy() {
        this.particles = [];
        this.sparkles = [];
    }

    start() {}

    // 创建粒子效果
    createParticles() {
        try {
            // 检查必要的info对象是否有效
            if (!this.info || isNaN(this.info.x) || isNaN(this.info.y) || isNaN(this.info.radius)) {
                console.warn("创建治疗粒子失败: info对象无效");
                return;
            }
            
            const particleCount = 15;

            // 创建围绕玩家的粒子
            for (let i = 0; i < particleCount; i++) {
                // 随机角度
                const angle = Math.random() * Math.PI * 2;
                // 随机距离
                const distance = this.info.radius * (0.2 + Math.random() * 0.8);
                // 计算位置
                const x = this.info.x + Math.cos(angle) * distance;
                const y = this.info.y + Math.sin(angle) * distance;

                // 随机大小
                const size = this.info.radius * (0.05 + Math.random() * 0.15);

                // 随机上升速度
                const speed = (0.01 + Math.random() * 0.03) * this.info.radius;

                // 随机生命周期
                const particleLifespan = 400 + Math.random() * 400;

                // 添加粒子
                this.particles.push({
                    x: x,
                    y: y,
                    size: size,
                    alpha: 0.2 + Math.random() * 0.5,
                    lifespan: particleLifespan,
                    maxLifespan: particleLifespan,
                    speed: speed,
                    angle: angle,
                });
            }

            // 创建闪光效果
            for (let i = 0; i < 5; i++) {
                const angle = Math.random() * Math.PI * 2;
                const sparkleLifespan = 200 + Math.random() * 300;

                this.sparkles.push({
                    angle: angle,
                    progress: 0,
                    lifespan: sparkleLifespan,
                    maxLifespan: sparkleLifespan,
                });
            }
        } catch (error) {
            console.error("创建初始治疗粒子时出错:", error);
        }
    }

    // 生成新粒子
    generateParticles() {
        try {
            const currentTime = Date.now()
            // 检查上次生成粒子的时间是否有效
            if (isNaN(this.lastParticleTime)) {
                this.lastParticleTime = currentTime
                return
            }
            
            // 检查时间间隔是否满足生成条件
            if (currentTime - this.lastParticleTime > this.particleInterval) {
                this.lastParticleTime = currentTime

                // 随机角度
                const angle = Math.random() * Math.PI * 2
                // 随机距离
                const distance = this.info.radius * (0.2 + Math.random() * 0.8)
                
                // 检查info对象是否有效
                if (!this.info || isNaN(this.info.x) || isNaN(this.info.y) || isNaN(this.info.radius)) {
                    return
                }
                
                // 计算位置
                const x = this.info.x + Math.cos(angle) * distance
                const y = this.info.y + Math.sin(angle) * distance

                // 随机大小
                const size = this.info.radius * (0.05 + Math.random() * 0.15)

                // 随机上升速度
                const speed = (0.01 + Math.random() * 0.03) * this.info.radius

                // 随机生命周期
                const particleLifespan = 400 + Math.random() * 400

                // 添加粒子
                this.particles.push({
                    x: x,
                    y: y,
                    size: size,
                    alpha: 0.2 + Math.random() * 0.5,
                    lifespan: particleLifespan,
                    maxLifespan: particleLifespan,
                    speed: speed,
                    angle: angle,
                })

                // 限制粒子数量
                while (this.particles.length > 30) {
                    this.particles.shift()
                }
            }
        } catch (error) {
            console.error("生成治疗粒子时出错:", error)
        }
    }

    update() {
        try {
            // 更新生命周期
            this.lifespan -= this.timeDelta

            // 如果效果已结束，销毁
            if (isNaN(this.lifespan) || this.lifespan <= 0) {
                this.destroy()
                return
            }

            // 生成新粒子
            this.generateParticles()

            // 更新所有粒子
            for (let i = this.particles.length - 1; i >= 0; i--) {
                const particle = this.particles[i]

                // 减少粒子生命周期
                particle.lifespan -= this.timeDelta

                // 计算透明度 - 确保不是NaN
                particle.alpha = isNaN(particle.lifespan) || isNaN(particle.maxLifespan) || particle.maxLifespan <= 0 
                    ? 0 
                    : particle.lifespan / particle.maxLifespan

                // 更新粒子位置（缓慢上升并围绕玩家旋转）
                if (!isNaN(particle.speed) && !isNaN(this.timeDelta)) {
                    particle.y -= (particle.speed * this.timeDelta) / 16
                }

                // 如果粒子生命周期结束，移除
                if (isNaN(particle.lifespan) || particle.lifespan <= 0) {
                    this.particles.splice(i, 1)
                }
            }

            // 更新闪光效果
            for (let i = this.sparkles.length - 1; i >= 0; i--) {
                const sparkle = this.sparkles[i]
                
                // 安全检查
                if (!sparkle) {
                    this.sparkles.splice(i, 1)
                    continue
                }
                
                // 更新生命周期
                sparkle.lifespan -= this.timeDelta
                
                // 安全计算进度
                if (!isNaN(sparkle.lifespan) && !isNaN(sparkle.maxLifespan) && sparkle.maxLifespan > 0) {
                    sparkle.progress = 1 - sparkle.lifespan / sparkle.maxLifespan
                } else {
                    sparkle.progress = 1 // 如果出现NaN，强制设为结束状态
                }

                // 如果闪光生命周期结束，移除并添加新的
                if (isNaN(sparkle.lifespan) || sparkle.lifespan <= 0) {
                    this.sparkles.splice(i, 1)

                    // 添加新的闪光
                    if (this.lifespan > 300) {
                        const angle = Math.random() * Math.PI * 2
                        const sparkleLifespan = 200 + Math.random() * 300

                        this.sparkles.push({
                            angle: angle,
                            progress: 0,
                            lifespan: sparkleLifespan,
                            maxLifespan: sparkleLifespan,
                        })
                    }
                }
            }

            this.draw()
        } catch (error) {
            console.error("更新治疗效果时出错:", error)
            this.destroy()
        }
    }

    draw() {
        try {
            // 确保ctx和gameMap存在
            if (!this.gameMap || !this.gameMap.ctx) {
                return;
            }
            
            // 绘制光环效果
            const pulseIntensity = Math.sin(Date.now() * 0.005) * 0.3 + 0.7
            this.gameMap.ctx.beginPath()
            const auraGradient = this.gameMap.ctx.createRadialGradient(
                this.info.x,
                this.info.y,
                0,
                this.info.x,
                this.info.y,
                this.info.radius * pulseIntensity
            )

            // 确保alpha是有效值
            const rawAlpha = this.lifespan / 800;
            const alpha = isNaN(rawAlpha) ? 0 : Math.min(0.5, rawAlpha);
            const alpha1 = (alpha * 0.7).toFixed(2); // 保留两位小数并转为字符串
            const alpha2 = (alpha * 0.5).toFixed(2);

            auraGradient.addColorStop(0, `rgba(100, 255, 100, ${alpha1})`)
            auraGradient.addColorStop(0.5, `rgba(50, 255, 50, ${alpha2})`)
            auraGradient.addColorStop(1, 'rgba(0, 200, 0, 0)')

            this.gameMap.ctx.fillStyle = auraGradient
            this.gameMap.ctx.arc(
                this.info.x,
                this.info.y,
                this.info.radius * pulseIntensity,
                0,
                Math.PI * 2
            )
            this.gameMap.ctx.fill()

            // 绘制闪光效果
            for (const sparkle of this.sparkles) {
                const distance = this.info.radius * sparkle.progress
                const x = this.info.x + Math.cos(sparkle.angle) * distance
                const y = this.info.y + Math.sin(sparkle.angle) * distance

                // 计算闪光透明度（开始和结束时降低）
                let sparkleAlpha = Math.sin(sparkle.progress * Math.PI) * 0.8;
                if (isNaN(sparkleAlpha)) sparkleAlpha = 0;

                // 绘制闪光
                this.gameMap.ctx.beginPath()
                const sparkleGradient = this.gameMap.ctx.createRadialGradient(
                    x,
                    y,
                    0,
                    x,
                    y,
                    this.info.radius * 0.15
                )

                sparkleGradient.addColorStop(0, `rgba(255, 255, 255, ${sparkleAlpha.toFixed(2)})`)
                sparkleGradient.addColorStop(0.6, `rgba(100, 255, 100, ${(sparkleAlpha * 0.5).toFixed(2)})`)
                sparkleGradient.addColorStop(1, 'rgba(0, 200, 0, 0)')

                this.gameMap.ctx.fillStyle = sparkleGradient
                this.gameMap.ctx.arc(x, y, this.info.radius * 0.15, 0, Math.PI * 2)
                this.gameMap.ctx.fill()
            }

            // 绘制所有粒子
            for (const particle of this.particles) {
                this.gameMap.ctx.beginPath()
                // 确保particle.alpha是有效值
                const particleAlpha = isNaN(particle.alpha) ? 0 : particle.alpha;
                this.gameMap.ctx.globalAlpha = particleAlpha;

                // 创建径向渐变
                const gradient = this.gameMap.ctx.createRadialGradient(
                    particle.x,
                    particle.y,
                    0,
                    particle.x,
                    particle.y,
                    particle.size
                )

                gradient.addColorStop(0, `rgba(255, 255, 255, ${particleAlpha.toFixed(2)})`)
                gradient.addColorStop(0.6, `rgba(150, 255, 150, ${(particleAlpha * 0.8).toFixed(2)})`)
                gradient.addColorStop(1, 'rgba(50, 200, 50, 0)')

                this.gameMap.ctx.fillStyle = gradient
                this.gameMap.ctx.arc(particle.x, particle.y, particle.size, 0, Math.PI * 2)
                this.gameMap.ctx.fill()
                this.gameMap.ctx.globalAlpha = 1.0
            }

            // 添加十字形发光效果
            this.gameMap.ctx.beginPath()
            this.gameMap.ctx.moveTo(this.info.x - this.info.radius * 0.3, this.info.y)
            this.gameMap.ctx.lineTo(this.info.x + this.info.radius * 0.3, this.info.y)
            this.gameMap.ctx.moveTo(this.info.x, this.info.y - this.info.radius * 0.3)
            this.gameMap.ctx.lineTo(this.info.x, this.info.y + this.info.radius * 0.3)
            
            // 确保strokeStyle alpha是有效值
            const crossAlpha = isNaN(this.lifespan) ? 0 : (this.lifespan / 800) * 0.7;
            this.gameMap.ctx.strokeStyle = `rgba(100, 255, 100, ${crossAlpha.toFixed(2)})`
            
            this.gameMap.ctx.lineWidth = this.info.radius * 0.1
            this.gameMap.ctx.stroke()
        } catch (error) {
            console.error("绘制治疗效果时出错:", error);
        }
    }
}